package 其他.斗地主之顺子;

/**
 * 牌的数量为13张, 是固定的~
 */

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main_递归 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String[] strings = s.split(" ");
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < strings.length; i++) {
            int value = mapping(strings[i]);
            if(value==-1)continue;
            list.add(value);
        }
        Collections.sort(list);// 对集合进行一个排序

        ArrayList<Integer> path = new ArrayList<>();
        ArrayList<ArrayList<Integer>> resultList = new ArrayList<>();

        dfs(list,path,resultList);

        if (resultList.size()==0){
            System.out.println("NO");
        }else {
            for (int i = 0; i < resultList.size(); i++) {
                for (Integer item : resultList.get(i)) {
                    System.out.print(reversMapping(item)+" ");
                }
                System.out.println();
            }
        }


    }

    // 递归方法
    private static void dfs(ArrayList<Integer> list, ArrayList<Integer> path, ArrayList<ArrayList<Integer>> resultList) {
        // 递归出口条件
        if (list.size()<5){
            return;
        }
        // 遍历 list
        ArrayList<Integer> arrayList = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {
            // 如果这个集合中元素个数为0 , 则直接添加
            if (path.size()==0){
                path.add(list.get(i));
                continue;
            }
            if (list.get(i) ==path.get(path.size()-1) +1){
                path.add(list.get(i));
            }else if(list.get(i)==path.get(path.size()-1)){
                 arrayList.add(list.get(i));
            }else {
                // 如果是其他的元素, 既不是满足连续条件, 又不满足相同条件
                // 把结果进行一个收集
                if (path.size()>=5){
                    ArrayList<Integer> temp = new ArrayList<>();
                    for (Integer item : path) {
                        temp.add(item);
                    }
                    resultList.add(temp);
                }

                // 清空path 集合
                path.clear();

                // 处理剩余的数据
                for (int j = i; j < list.size(); j++) {
                    arrayList.add(list.get(j));
                }

                break; // 退出循环

            }

            // 特判, 本次循环结束后,但是最后没有碰到这个 差距>=1 的,  就需要对结果进行一次收集
            if (i==list.size()-1){
                if (path.size()>=5){
                    ArrayList<Integer> temp = new ArrayList<>();
                    for (Integer item : path) {
                        temp.add(item);
                    }
                    resultList.add(temp);
                }
            }


        }
        // 递归
        dfs(arrayList,path,resultList);
    }




    public static int mapping(String a){
        switch (a){
            case "J":
                return 11;
            case "Q":
                return 12;
            case "K":
                return 13;
            case "A":
                return 14;
            case "2":
                return -1;
            default:
                return Integer.valueOf(a);
        }
    }

    public static String reversMapping(int a){
        switch (a){
            case 11:
                return "J";
            case 12:
                return "Q";
            case 13:
                return "K";
            case 14:
                return "A";
            default:
                return String.valueOf(a);
        }
    }
}
